/// Simple example Permissions for a shared counter
module counter::permission;

/// Permissions for a shared counter 
public enum CounterPermission has copy, drop, store {
    // --- Used for a super-admin role who can do everything ---
    /// Destroy the Counter
    DeleteCounter,
    /// Manage Capabilities including adding and revoking
    ManageCapabilities,
    /// Manage Roles including adding, removing and updating
    ManageRoles,

    // --- Counter Management, could be used for a counter ---
    /// Increment the Counter
    IncrementCounter,
    /// Reset the Counter
    ResetCounter,
}

public fun delete_counter(): CounterPermission {
    CounterPermission::DeleteCounter
}

public fun manage_capabilities(): CounterPermission {
    CounterPermission::ManageCapabilities
}

public fun manage_roles(): CounterPermission {
    CounterPermission::ManageRoles
}

public fun increment_counter(): CounterPermission {
    CounterPermission::IncrementCounter
}

public fun reset_counter(): CounterPermission {
    CounterPermission::ResetCounter
}

// --------------------------- Functions creating permission sets for often used roles ---------------------------

/// Create permissions typical used for the `super-admin` role permissions
public fun super_admin_permissions(): VecSet<CounterPermission> {
    let mut perms = vec_set::empty();
    perms.insert(delete_counter());
    perms.insert(manage_capabilities());
    perms.insert(manage_roles());
    perms.insert(increment_counter());
    perms.insert(reset_counter());
    perms
}

public fun counter_admin_permissions(): VecSet<CounterPermission> {
    let mut perms = vec_set::empty();
    perms.insert(increment_counter());
    perms.insert(reset_counter());
    perms
}

#[error]
const EPermissionDenied: vector<u8> = b"The role associated with the provided capability does not have the required permission";

public struct Counter has key {
    id: UID,
    value: u64,
    roles: role_map::RoleMap<CounterPermission>
}

public fun create(
    ctx: &mut TxContext,
): (Capability, ID) {
    let counter_uid = object::new(ctx);
    let counter_id = object::uid_to_inner(&counter_uid);

    // Create a `RoleAdminPermissions` instance to configure the permissions
    // that will be needed by users to administer roles with the `RoleMap`.
    //
    // There are three actions that need to be configured with a permission of your choice:
    // * `add`: Permission required to add a new role
    // * `delete`: Permission required to delete an existing role
    // * `update` Permission required to update permissions associated with an existing role
    //
    // In this example we allow to use all three actions with the `ManageRoles` permission.
    //
   let role_admin_permissions = role_map::new_role_admin_permissions(
        counter::permission::manage_roles(),
        counter::permission::manage_roles(),
        counter::permission::manage_roles(),
    );

    // Create a `CapabilityAdminPermissions` instance to configure the permissions
    // that will be needed by users to issue and revoke cabilities with the `RoleMap`.
    //
    // There are two actions that need to be configured with a permission of your choice:
    // * `add`: Permission required to add (issue) a new capability
    // * `revoke`: Permission required to revoke an existing capability
    //
    // In this example we allow to use all two actions with the `ManageCapabilities` permission.
    //
    let capability_admin_permissions = role_map::new_capability_admin_permissions(
        counter::permission::manage_capabilities(),
        counter::permission::manage_capabilities(),
    );

    let (roles, admin_cap) = role_map::new(
        counter_id,
        "super-admin",
        permission::super_admin_permissions(),
        role_admin_permissions,
        capability_admin_permissions,
        ctx,
    );

    let counter = Counter {
        id: counter_uid,
        0,
        roles,
    };
    transfer::share_object(counter);

    (admin_cap, counter_id)
}

public fun increment(
    counter: &mut Counter,
    cap: &Capability,
    clock: &Clock,
    ctx: &TxContext,
) {
    assert!(
        counter
            .roles
            .is_capability_valid(
                cap,
                &counter::permission::increment_counter(),
                clock,
                ctx,
            ),
        EPermissionDenied,
    );
    counter.value = counter.value + 1;
}

const INITIAL_TIME_FOR_TESTING: u64 = 1234;

/// Test capability lifecycle: creation, usage, revocation and destruction in a complete workflow.
///
/// This test validates:
/// - A capability can be created for the `counter-admin` role
/// - The Capability can be used to perform authorized actions
/// - The Capability can be revoked
/// - The Capability can be destroyed thereafter
#[test]

fun test_capability_lifecycle() {
    let super_admin_user = @0xAD;
    let counter_admin_user = @0xB0B;

    let mut scenario = ts::begin(super_admin_user);

    // Setup: Create Counter
    let (super_admin_cap, counter_id) = counter::create(ts::ctx(scenario));

    // Create an additional CounterAdmin role
    ts::next_tx(&mut scenario, super_admin_user);
    {
        let super_admin_cap = ts::take_from_sender<Capability>(scenario);
        let counter = ts::take_shared<Counter>(scenario);
        let clock = iota::clock::create_for_testing(ts::ctx(scenario));

        // Initially only the super-admin cap should be tracked
        assert!(counter.roles().issued_capabilities().size() == 1, 0);

        counter
            .roles_mut()
            .create_role(
                &super_admin_cap,
                string::utf8(b"counter-admin"),
                permission::counter_admin_permissions(),
                &clock,
                ts::ctx(&mut scenario),
            );

        iota::clock::destroy_for_testing(clock);
        ts::return_to_sender(scenario, super_admin_cap);
        ts::return_shared(counter);
    };

    // Issue the CounterAdmin capability to another user
    ts::next_tx(&mut scenario, super_admin_user);
    let counter_admin_cap_id = {
        let super_admin_cap = ts::take_from_sender<Capability>(scenario);
        let counter = ts::take_shared<Counter>(scenario);
        let clock = iota::clock::create_for_testing(ts::ctx(scenario));

        let counter_cap = counter
            .roles_mut()
            .new_capability_without_restrictions(
                &super_admin_cap,
                &string::utf8(b"counter-admin"),
                &clock,
                ts::ctx(&mut scenario),
            );
        let counter_admin_cap_id = object::id(&counter_cap);
        transfer::public_transfer(counter_cap, counter_admin_user);

        // Verify all capabilities are tracked
        assert!(counter.roles().issued_capabilities().size() == 2, 1); // super-admin + counter
        assert!(counter.roles().issued_capabilities().contains(&counter_admin_cap_id), 2);

        iota::clock::destroy_for_testing(clock);
        ts::return_to_sender(scenario, super_admin_cap);
        ts::return_shared(counter);

        counter_admin_cap_id
    };

    // Use CounterAdmin capability to increment the counter
    ts::next_tx(&mut scenario, counter_admin_user);
    {
        let counter_admin_cap = ts::take_from_sender<Capability>(scenario);
        let counter = ts::take_shared<Counter>(scenario);
        let clock = iota::clock::create_for_testing(ts::ctx(scenario));

        counter.increment(
            &counter_admin_cap,
            &clock,
            ts::ctx(&mut scenario),
        );

        assert!(counter.value() == 1, 3);

        iota::clock::destroy_for_testing(clock);
        ts::return_to_sender(scenario, counter_admin_cap);
        ts::return_shared(counter);
    };

    // Revoke the CounterAdmin capability
    ts::next_tx(&mut scenario, super_admin_user);
    {
        let super_admin_cap = ts::take_from_sender<Capability>(scenario);
        let counter = ts::take_shared<Counter>(scenario);
        let clock = iota::clock::create_for_testing(ts::ctx(scenario));

        counter
            .roles_mut()
            .revoke_capability(
                &super_admin_cap,
                &counter_admin_cap_id,
                &clock,
                ts::ctx(&mut scenario),
            );

        // Verify capability was removed from the issued_capabilities list
        assert!(counter.roles().issued_capabilities().size() == 1, 4); // super-admin only
        assert!(!counter.roles().issued_capabilities().contains(&record_cap_id), 5);

        iota::clock::destroy_for_testing(clock);
        ts::return_to_sender(scenario, super_admin_cap);
        ts::return_shared(counter);
    };

    // The `counter_admin_user` can destroy the capability before it is revoked or after it is revoked.
    // Here we test destroying after revocation.
    // If the capability is destroyed before revocating it, the capability would be revoked automatically during `destroy_capability()`.
    ts::next_tx(&mut scenario, counter_admin_user);
    {
        let counter_admin_cap = ts::take_from_sender<Capability>(scenario);
        let counter = ts::take_shared<Counter>(scenario);

        counter
            .roles_mut()
            .destroy_capability(counter_admin_cap);

        ts::return_shared(counter);
    }
}